﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

//int* smallerNumbersThanCurrent(int* nums, int numsSize)
//{
//    int*
//    for (int i = 0; i < numsSize; i++)
//    {
//        int count = 0;
//        for (int j = 0; j < nums; j++)
//        {
//            if (*(nums + i) > *(nums + j))
//            {
//                count++;//计数
//            }
//        }
//        *(returnSize + i) = count;
//    }
//    return returnSize;
//}
//int main1()
//{
//
//    int arr[] = { 8,12,2,3 };
//    int sz = 4;
//    smallerNumbersThanCurrent(arr, sz);
//	return 0;
//}

//int main11()
//{
//    int arr[] = { 8,2,2,3 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    qsort(arr, sz, sizeof(int), compare);//把数组变成有序的
//    /*for (int i = 0; i< sz; i++)
//    {
//        printf("%d ", arr[i]);
//    }*/
//    int l = 0;//左指针
//    int r = sz - 1;//右指针
//    //int mid = l + (r - l) / (2.0);
//    int p[4] = { 0 };
//    while (l <= r)
//    {
//
//        for (int i = 0; i < sz; i++)
//        {
//            int mid = l + (r - l) / (2.0);
//
//            if (arr[i] == arr[mid])
//            {
//                *(p + i) = i;//对应下标就是小于当前元素的个数
//                continue;
//            }
//            else if (arr[i] > arr[mid])
//            {
//                //动左指针
//                l = mid + 1;
//            }
//            else
//            {
//                r = mid - 1;
//            }
//        }
//    }
//    for (int i = 0; i < sz; i++)
//    {
//        printf("%d ", p[i]);
//    }
//    return 0;
//}
int main3()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int k = 8;
    int l = 0;
    int r = 9;
    int mid = 0;
    //二分查找算法
    while (l <= r)
    {
        mid = l + (r - l) / (2.0);
        if (k == arr[mid])
        {
            return 0;
        }
        else if (k < arr[mid])
        {
            r = mid - 1;

        }
        else
        {
            l = mid + 1;
        }
    }
    return  0;
}
int compare(const void* p1, const void* p2)
{
    return (*(int*)p1 - *(int*)p2);
}
int search(int* p, int size, int num)
{
    int l = 0;
    int r = size - 1;
    int mid = 0;
    //二分查找算法
    while (l < r) 
    {
                //mid为l和r的中点，向下取整
                int mid = (l + r) / 2;
                //如果在有序数组中下标为中点的数⼩于要查找的数，则要查找的数⼀定在中点右边，将左边界修改为中
                if (p[mid] < num) l = mid + 1;
                //否则在中点处或者中点左边部分，将右边界修改为中点，
                else r = mid;
           
    }
            //当查找完成时l=r，返回其中⼀个即可
            return l;
}
int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize)
{
    int* p = (int*)malloc(sizeof(int) * numsSize);//对原数组复制
    if (p == NULL)
    {
        perror("malloc\n");
    }
    int* copy = p;
    for (int i = 0; i < numsSize; i++)
    {
        copy[i] = nums[i];
    }
    int* back = (int*)malloc(sizeof(int) * numsSize);//用来存放个数
    qsort(copy, numsSize, sizeof(int), compare);//数组拍成升序
    for (int i = 0; i < numsSize; i++)
    {
        back[i] = search(copy, numsSize, nums[i]);
    }
    *returnSize = numsSize;
    return back;

}

//int low(int* order, int orderSize, int u) {
//    int i;
//    //定义左右两边界，l为最左边，r为最右边
//    int l = 0, r = orderSize - 1;
//
//    //当l<r时表⽰l~r之间还未被查找
//    while (l < r) {
//        //mid为l和r的中点，向下取整
//        int mid = (l + r) / 2;
//        //如果在有序数组中下标为中点的数⼩于要查找的数，则要查找的数⼀定在中点右边，将左边界修改为中
//        if (order[mid] < u) l = mid + 1;
//        //否则在中点处或者中点左边部分，将右边界修改为中点，
//        else r = mid;
//    }
//    //当查找完成时l=r，返回其中⼀个即可
//    return l;
//}
//int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize) {
//    //定义答案数组
//    int* ans = malloc(numsSize * sizeof(int));
//    //定义有序数组
//    int* order = malloc(numsSize * sizeof(int));
//    int i = 0, j = 0;
//
//    //将原数组中的数放⼊有序数组，之后进⾏排序
//    for (i = 0; i < numsSize; i++) order[i] = nums[i];
//
//    //此段代码为冒泡排序，时间复杂度较⾼，有兴趣可以修改此段代码为其他时间复杂度较低的排序代
//    for (i = 0; i < numsSize; i++) {
//        //此层循环为将当前数组最⼤值（除了之前已经找到的最⼤值之外）放⼊数组最后⾯（nunmsS
//        for (j = 0; j < numsSize - i - 1; j++) {
//            //如果两个相邻的数之间左边的⽐较⼤，则交换相邻的两个数
//            if (order[j] > order[j + 1]) {
//                int u = order[j];
//                order[j] = order[j + 1];
//                order[j + 1] = u;
//            }
//        }
//    }
//
//    //更新答案数组
//    for (int i = 0; i < numsSize; i++) {
//        //将当前数在有序数组中的下标存⼊答案数组，order：有序数组，numsSize：数组⻓度，nums[
//        ans[i] = low(order, numsSize, nums[i]);
//    }
//
//    //更新数组⻓度并返回数组
//    *returnSize = numsSize;
//    return ans;
//}
int main22()
{
    int nums[10] = { 8,5,2,0,1,4,7,9,6,3 };
    int numsSize = sizeof(nums) / sizeof(nums[0]);
    int returnSize[10] = { 0 };
    int*p = smallerNumbersThanCurrent(nums, numsSize, returnSize);
    for (int i = 0; i < numsSize; i++)
    {
        printf("%d ", *(p + i));
    }

    return 0;
}
int percentageLetter(char* s, char letter) {
    int len = strlen(s);//总的字母数目
    int count1 = 0;
    while (*s)
    {
        if (*s == letter)
        {
            count1++;
        }
        s++;
    }
    if (count1 == 0)
    {
        return 0;
    }
    else
    {
        return  floor(count1 / (len * 1.0)) * 100;
    }
}
int main()
{
    char* s = "hello bit";
    char l = 'l';
   printf("%d", percentageLetter(s, l));
    return 0;
}